Avoid duplicating GtkEditable APIs. Port existing users.
page_number = gtk_assistant_get_current_page (assistant);
current_page = gtk_assistant_get_nth_page (assistant, page_number);
- text = gtk_entry_get_text (GTK_ENTRY (widget));
+ text = gtk_editable_get_text (GTK_EDITABLE (widget));
if (text && *text)
gtk_assistant_set_page_complete (assistant, current_page, TRUE);
clipboard = gtk_widget_get_clipboard (entry);
/* Set clipboard text */
- gdk_clipboard_set_text (clipboard, gtk_entry_get_text (GTK_ENTRY (entry)));
+ gdk_clipboard_set_text (clipboard, gtk_editable_get_text (GTK_EDITABLE (entry)));
}
void
if (text)
{
/* Set the entry text */
- gtk_entry_set_text (GTK_ENTRY (entry), text);
+ gtk_editable_set_text (GTK_EDITABLE (entry), text);
g_free (text);
}
else
{
if (entry->mask)
{
- if (!g_regex_match_simple (entry->mask, gtk_entry_get_text (GTK_ENTRY (entry)), 0, 0))
+ if (!g_regex_match_simple (entry->mask, gtk_editable_get_text (GTK_EDITABLE (entry)), 0, 0))
{
PangoAttrList *attrs;
label = gtk_label_new_with_mnemonic ("_Entry 1");
gtk_grid_attach (GTK_GRID (table), label, 0, 0, 1, 1);
local_entry1 = gtk_entry_new ();
- gtk_entry_set_text (GTK_ENTRY (local_entry1), gtk_entry_get_text (GTK_ENTRY (entry1)));
+ gtk_editable_set_text (GTK_EDITABLE (local_entry1), gtk_editable_get_text (GTK_EDITABLE (entry1)));
gtk_grid_attach (GTK_GRID (table), local_entry1, 1, 0, 1, 1);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), local_entry1);
gtk_grid_attach (GTK_GRID (table), label, 0, 1, 1, 1);
local_entry2 = gtk_entry_new ();
- gtk_entry_set_text (GTK_ENTRY (local_entry2), gtk_entry_get_text (GTK_ENTRY (entry2)));
+ gtk_editable_set_text (GTK_EDITABLE (local_entry2), gtk_editable_get_text (GTK_EDITABLE (entry2)));
gtk_grid_attach (GTK_GRID (table), local_entry2, 1, 1, 1, 1);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), local_entry2);
if (response == GTK_RESPONSE_OK)
{
- gtk_entry_set_text (GTK_ENTRY (entry1), gtk_entry_get_text (GTK_ENTRY (local_entry1)));
- gtk_entry_set_text (GTK_ENTRY (entry2), gtk_entry_get_text (GTK_ENTRY (local_entry2)));
+ gtk_editable_set_text (GTK_EDITABLE (entry1), gtk_editable_get_text (GTK_EDITABLE (local_entry1)));
+ gtk_editable_set_text (GTK_EDITABLE (entry2), gtk_editable_get_text (GTK_EDITABLE (local_entry2)));
}
gtk_widget_destroy (dialog);
gtk_container_child_get (GTK_CONTAINER (fixed), entry, "x", &x, "y", &y, NULL);
label = GTK_WIDGET (g_object_get_data (G_OBJECT (entry), "label"));
- gtk_label_set_text (GTK_LABEL (label), gtk_entry_get_text (GTK_ENTRY (entry)));
+ gtk_label_set_text (GTK_LABEL (label), gtk_editable_get_text (GTK_EDITABLE (entry)));
gtk_widget_destroy (entry);
}
g_object_set_data (G_OBJECT (entry), "label", child);
- gtk_entry_set_text (GTK_ENTRY (entry), gtk_label_get_text (GTK_LABEL (child)));
+ gtk_editable_set_text (GTK_EDITABLE (entry), gtk_label_get_text (GTK_LABEL (child)));
g_signal_connect (entry, "activate", G_CALLBACK (edit_label_done), NULL);
gtk_fixed_put (GTK_FIXED (fixed), entry, x, y);
gtk_widget_grab_focus (entry);
char *font_desc;
char *features;
- text = gtk_entry_get_text (GTK_ENTRY (entry));
+ text = gtk_editable_get_text (GTK_EDITABLE (entry));
if (gtk_label_get_selection_bounds (GTK_LABEL (label), &ins, &bound))
{
char *str;
str = g_strdup_printf ("%g", gtk_adjustment_get_value (adjustment));
- gtk_entry_set_text (GTK_ENTRY (entry), str);
+ gtk_editable_set_text (GTK_EDITABLE (entry), str);
g_free (str);
update_display ();
gdouble value;
gchar *err = NULL;
- value = g_strtod (gtk_entry_get_text (entry), &err);
+ value = g_strtod (gtk_editable_get_text (GTK_EDITABLE (entry)), &err);
if (err != NULL)
gtk_adjustment_set_value (adjustment, value);
}
gtk_grid_attach (GTK_GRID (variations_grid), axis_scale, 1, i, 1, 1);
axis_entry = gtk_entry_new ();
gtk_widget_set_valign (axis_entry, GTK_ALIGN_BASELINE);
- gtk_entry_set_width_chars (GTK_ENTRY (axis_entry), 4);
+ gtk_editable_set_width_chars (GTK_EDITABLE (axis_entry), 4);
gtk_grid_attach (GTK_GRID (variations_grid), axis_entry, 2, i, 1, 1);
axis = g_new (Axis, 1);
static void
switch_to_entry (void)
{
- text = g_strdup (gtk_entry_get_text (GTK_ENTRY (entry)));
+ text = g_strdup (gtk_editable_get_text (GTK_EDITABLE (entry)));
gtk_stack_set_visible_child_name (GTK_STACK (stack), "entry");
gtk_widget_grab_focus (entry);
}
{
if (keyval == GDK_KEY_Escape)
{
- gtk_entry_set_text (GTK_ENTRY (entry), text);
+ gtk_editable_set_text (GTK_EDITABLE (entry), text);
stop_edit ();
return GDK_EVENT_STOP;
}
static void
do_number (GtkButton *button, GtkEntry *entry)
{
- gtk_entry_set_text (entry, gtk_button_get_label (button));
+ gtk_editable_set_text (GTK_EDITABLE (entry), gtk_button_get_label (button));
}
GtkWidget *
static void
clear_entry (GtkEntry *entry)
{
- gtk_entry_set_text (entry, "");
+ gtk_editable_set_text (GTK_EDITABLE (entry), "");
}
static void
gchar *err;
gdouble res;
- buf = gtk_spin_button_get_text (spin_button);
+ buf = gtk_editable_get_text (GTK_EDITABLE (spin_button));
res = strtol (buf, &err, 16);
*new_val = res;
if (*err)
buf = g_strdup ("0x00");
else
buf = g_strdup_printf ("0x%.2X", (gint) val);
- if (strcmp (buf, gtk_spin_button_get_text (spin_button)))
- gtk_spin_button_set_text (spin_button, buf);
+ if (strcmp (buf, gtk_editable_get_text (GTK_EDITABLE (spin_button))))
+ gtk_editable_set_text (GTK_EDITABLE (spin_button), buf);
g_free (buf);
return TRUE;
gchar *endh;
gchar *endm;
- text = gtk_spin_button_get_text (spin_button);
+ text = gtk_editable_get_text (GTK_EDITABLE (spin_button));
str = g_strsplit (text, ":", 2);
if (g_strv_length (str) == 2)
hours = gtk_adjustment_get_value (adjustment) / 60.0;
minutes = (hours - floor (hours)) * 60.0;
buf = g_strdup_printf ("%02.0f:%02.0f", floor (hours), floor (minutes + 0.5));
- if (strcmp (buf, gtk_spin_button_get_text (spin_button)))
- gtk_spin_button_set_text (spin_button, buf);
+ if (strcmp (buf, gtk_editable_get_text (GTK_EDITABLE (spin_button))))
+ gtk_editable_set_text (GTK_EDITABLE (spin_button), buf);
g_free (buf);
return TRUE;
for (i = 1; i <= 12; i++)
{
tmp1 = g_ascii_strup (month[i - 1], -1);
- tmp2 = g_ascii_strup (gtk_spin_button_get_text (spin_button), -1);
+ tmp2 = g_ascii_strup (gtk_editable_get_text (GTK_EDITABLE (spin_button)), -1);
if (strstr (tmp1, tmp2) == tmp1)
found = TRUE;
g_free (tmp1);
for (i = 1; i <= 12; i++)
if (fabs (value - (double)i) < 1e-5)
{
- if (strcmp (month[i-1], gtk_spin_button_get_text (spin_button)))
- gtk_spin_button_set_text (spin_button, month[i-1]);
+ if (strcmp (month[i-1], gtk_editable_get_text (GTK_EDITABLE (spin_button))))
+ gtk_editable_set_text (GTK_EDITABLE (spin_button), month[i-1]);
}
return TRUE;
{
const gchar *text;
- text = gtk_entry_get_text (entry);
+ text = gtk_editable_get_text (GTK_EDITABLE (entry));
if (text[0] == '\0')
return;
gboolean visible;
search = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (win->search));
- search_text = gtk_entry_get_text (GTK_ENTRY (win->searchentry));
+ search_text = gtk_editable_get_text (GTK_EDITABLE (win->searchentry));
if (win->symbolic)
column = ICON_STORE_SYMBOLIC_NAME_COLUMN;
{
const gchar *text;
- text = gtk_entry_get_text (entry);
+ text = gtk_editable_get_text (GTK_EDITABLE (entry));
gtk_widget_set_sensitive (button, strlen (text) > 0);
}
GtkTextBuffer *buffer;
GtkTextIter start, match_start, match_end;
- text = gtk_entry_get_text (entry);
+ text = gtk_editable_get_text (GTK_EDITABLE (entry));
if (text[0] == '\0')
return;
gtk_entry_new_with_buffer
gtk_entry_get_buffer
gtk_entry_set_buffer
-gtk_entry_set_text
-gtk_entry_get_text
gtk_entry_get_text_length
gtk_entry_set_visibility
gtk_entry_get_visibility
gtk_entry_get_activates_default
gtk_entry_set_has_frame
gtk_entry_get_has_frame
-gtk_entry_set_width_chars
-gtk_entry_get_width_chars
-gtk_entry_set_max_width_chars
-gtk_entry_get_max_width_chars
gtk_entry_set_alignment
gtk_entry_get_alignment
gtk_entry_set_placeholder_text
gtk_spin_button_get_update_policy
gtk_spin_button_get_value
gtk_spin_button_get_wrap
-gtk_spin_button_set_text
-gtk_spin_button_get_text
-gtk_spin_button_set_max_width_chars
-gtk_spin_button_get_max_width_chars
-gtk_spin_button_set_width_chars
-gtk_spin_button_get_width_chars
GTK_INPUT_ERROR
<SUBSECTION Standard>
GTK_SPIN_BUTTON
</section>
<section>
- <title>Adapt to changes in the API of GtkEntry and GtkSearchEntry</title>
+ <title>Adapt to changes in the API of GtkEntry, GtkSearchEntry adn GtkSpinButton</title>
<para>
The GtkEditable has been made more useful, and the core functionality of
GtkEntry has been broken out as a GtkText widget. GtkEntry, GtkSearchEntry,
<para>
Use GtkEditable API for editable functionality, and widget-specific APIs for
things that go beyond the common interface. For password entries, use
- GtkPasswordEntry.
+ GtkPasswordEntry. As an example, gtk_spin_button_set_max_width_chars()
+ has been removed in favor of gtk_editable_set_max_width_chars().
</para>
</section>
widget = gtk_entry_new ();
gtk_widget_set_halign (widget, GTK_ALIGN_FILL);
gtk_widget_set_valign (widget, GTK_ALIGN_CENTER);
- gtk_entry_set_text (GTK_ENTRY (widget), "Entry");
+ gtk_editable_set_text (GTK_EDITABLE (widget), "Entry");
gtk_editable_set_position (GTK_EDITABLE (widget), -1);
return new_widget_info ("entry", widget, SMALL);
g_object_unref (model);
child = gtk_bin_get_child (GTK_BIN (widget));
- gtk_entry_set_text (GTK_ENTRY (child), "Combo Box Entry");
+ gtk_editable_set_text (GTK_EDITABLE (child), "Combo Box Entry");
gtk_widget_set_halign (widget, GTK_ALIGN_CENTER);
gtk_widget_set_valign (widget, GTK_ALIGN_CENTER);
widget = gtk_search_bar_new ();
entry = gtk_search_entry_new ();
- gtk_entry_set_text (GTK_ENTRY (entry), "Search Bar");
+ gtk_editable_set_text (GTK_EDITABLE (entry), "Search Bar");
gtk_container_add (GTK_CONTAINER (widget), entry);
gtk_widget_show (entry);
GtkTextBuffer *buffer;
GtkTextIter start, match_start, match_end;
- text = gtk_entry_get_text (entry);
+ text = gtk_editable_get_text (GTK_EDITABLE (entry));
if (text[0] == '\0')
return;
const gchar *word;
word = gtk_button_get_label (button);
- gtk_entry_set_text (GTK_ENTRY (win->searchentry), word);
+ gtk_editable_set_text (GTK_EDITABLE (win->searchentry), word);
}
static void
GtkTextBuffer *buffer;
GtkTextIter start, match_start, match_end;
- text = gtk_entry_get_text (entry);
+ text = gtk_editable_get_text (GTK_EDITABLE (entry));
if (text[0] == '\0')
return;
GtkTextBuffer *buffer;
GtkTextIter start, match_start, match_end;
- text = gtk_entry_get_text (entry);
+ text = gtk_editable_get_text (GTK_EDITABLE (entry));
if (text[0] == '\0')
return;
const gchar *word;
word = gtk_button_get_label (button);
- gtk_entry_set_text (GTK_ENTRY (win->searchentry), word);
+ gtk_editable_set_text (GTK_EDITABLE (win->searchentry), word);
}
static void
GtkTextBuffer *buffer;
GtkTextIter start, match_start, match_end;
- text = gtk_entry_get_text (entry);
+ text = gtk_editable_get_text (GTK_EDITABLE (entry));
if (text[0] == '\0')
return;
const gchar *word;
word = gtk_button_get_label (button);
- gtk_entry_set_text (GTK_ENTRY (win->searchentry), word);
+ gtk_editable_set_text (GTK_EDITABLE (win->searchentry), word);
}
static void
str = g_strjoinv (",", accels);
g_strfreev (accels);
- gtk_entry_set_text (entry, str);
+ gtk_editable_set_text (GTK_EDITABLE (entry), str);
}
static void
if (!action)
return;
- str = gtk_entry_get_text (entry);
+ str = gtk_editable_get_text (GTK_EDITABLE (entry));
accels = g_strsplit (str, ",", 0);
gtk_application_set_accels_for_action (gtk_window_get_application (user_data), action, (const gchar **) accels);
if (gtk_combo_box_get_has_entry (GTK_COMBO_BOX (combo)))
{
entry = GTK_ENTRY (gtk_bin_get_child (GTK_BIN (combo)));
- new_text = g_strdup (gtk_entry_get_text (entry));
+ new_text = g_strdup (gtk_editable_get_text (GTK_EDITABLE (entry)));
}
else
{
g_object_get (cell_text, "text", &text, NULL);
if (text)
- gtk_entry_set_text (GTK_ENTRY (gtk_bin_get_child (GTK_BIN (combo))),
- text);
+ gtk_editable_set_text (GTK_EDITABLE (gtk_bin_get_child (GTK_BIN (combo))), text);
g_free (text);
}
else
{
path = g_object_get_data (G_OBJECT (widget), GTK_CELL_RENDERER_SPIN_PATH);
- new_text = gtk_entry_get_text (GTK_ENTRY (widget));
+ new_text = gtk_editable_get_text (GTK_EDITABLE (widget));
g_signal_emit_by_name (data, "edited", path, new_text);
}
}
return;
path = g_object_get_data (G_OBJECT (entry), GTK_CELL_RENDERER_TEXT_PATH);
- new_text = gtk_entry_get_text (GTK_ENTRY (entry));
+ new_text = gtk_editable_get_text (GTK_EDITABLE (entry));
g_signal_emit (data, text_cell_renderer_signals[EDITED], 0, path, new_text);
}
gtk_entry_set_has_frame (GTK_ENTRY (priv->entry), FALSE);
gtk_entry_set_alignment (GTK_ENTRY (priv->entry), xalign);
- gtk_entry_set_width_chars (GTK_ENTRY (priv->entry), 5);
+ gtk_editable_set_width_chars (GTK_EDITABLE (priv->entry), 5);
if (priv->text)
- gtk_entry_set_text (GTK_ENTRY (priv->entry), priv->text);
+ gtk_editable_set_text (GTK_EDITABLE (priv->entry), priv->text);
g_object_set_data_full (G_OBJECT (priv->entry), I_(GTK_CELL_RENDERER_TEXT_PATH), g_strdup (path), g_free);
gtk_editable_select_region (GTK_EDITABLE (priv->entry), 0, -1);
scale_round (color->red, 255),
scale_round (color->green, 255),
scale_round (color->blue, 255));
- gtk_entry_set_text (GTK_ENTRY (editor->priv->entry), text);
+ gtk_editable_set_text (GTK_EDITABLE (editor->priv->entry), text);
editor->priv->text_changed = FALSE;
g_free (text);
}
g_signal_emit (combo_box, combo_box_signals[FORMAT_ENTRY_TEXT], 0,
path_str, &text);
- gtk_entry_set_text (entry, text);
+ gtk_editable_set_text (GTK_EDITABLE (entry), text);
g_signal_handlers_unblock_by_func (entry,
gtk_combo_box_entry_contents_changed,
GtkWidget *entry;
entry = gtk_bin_get_child (GTK_BIN (combo_box));
- text = g_strdup (gtk_entry_get_text (GTK_ENTRY (entry)));
+ text = g_strdup (gtk_editable_get_text (GTK_EDITABLE (entry)));
}
else if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (combo_box), &iter))
{
gtk_text_set_buffer (GTK_TEXT (priv->text), buffer);
}
-/**
- * gtk_entry_set_text:
- * @entry: a #GtkEntry
- * @text: the new text
- *
- * Sets the text in the widget to the given
- * value, replacing the current contents.
- *
- * See gtk_entry_buffer_set_text().
- */
-void
-gtk_entry_set_text (GtkEntry *entry,
- const gchar *text)
-{
- GtkEntryPrivate *priv = gtk_entry_get_instance_private (entry);
-
- gtk_editable_set_text (GTK_EDITABLE (priv->text), text);
-}
-
/**
* gtk_entry_set_visibility:
* @entry: a #GtkEntry
}
-/**
- * gtk_entry_get_text:
- * @entry: a #GtkEntry
- *
- * Retrieves the contents of the entry widget.
- * See also gtk_editable_get_chars().
- *
- * This is equivalent to getting @entry's #GtkEntryBuffer and calling
- * gtk_entry_buffer_get_text() on it.
- *
- * Returns: a pointer to the contents of the widget as a
- * string. This string points to internally allocated
- * storage in the widget and must not be freed, modified or
- * stored.
- **/
-const gchar*
-gtk_entry_get_text (GtkEntry *entry)
-{
- GtkEntryPrivate *priv = gtk_entry_get_instance_private (entry);
-
- g_return_val_if_fail (GTK_IS_ENTRY (entry), NULL);
-
- return gtk_editable_get_text (GTK_EDITABLE (priv->text));
-}
-
/**
* gtk_entry_set_max_length:
* @entry: a #GtkEntry
return gtk_text_get_activates_default (GTK_TEXT (priv->text));
}
-/**
- * gtk_entry_set_width_chars:
- * @entry: a #GtkEntry
- * @n_chars: width in chars
- *
- * Changes the size request of the entry to be about the right size
- * for @n_chars characters. Note that it changes the size
- * request, the size can still be affected by
- * how you pack the widget into containers. If @n_chars is -1, the
- * size reverts to the default entry size.
- **/
-void
-gtk_entry_set_width_chars (GtkEntry *entry,
- gint n_chars)
-{
- GtkEntryPrivate *priv = gtk_entry_get_instance_private (entry);
-
- g_return_if_fail (GTK_IS_ENTRY (entry));
-
- gtk_editable_set_width_chars (GTK_EDITABLE (priv->text), n_chars);
-}
-
-/**
- * gtk_entry_get_width_chars:
- * @entry: a #GtkEntry
- *
- * Gets the value set by gtk_entry_set_width_chars().
- *
- * Returns: number of chars to request space for, or negative if unset
- **/
-gint
-gtk_entry_get_width_chars (GtkEntry *entry)
-{
- GtkEntryPrivate *priv = gtk_entry_get_instance_private (entry);
-
- g_return_val_if_fail (GTK_IS_ENTRY (entry), 0);
-
- return gtk_editable_get_width_chars (GTK_EDITABLE (priv->text));
-}
-
-/**
- * gtk_entry_set_max_width_chars:
- * @entry: a #GtkEntry
- * @n_chars: the new desired maximum width, in characters
- *
- * Sets the desired maximum width in characters of @entry.
- */
-void
-gtk_entry_set_max_width_chars (GtkEntry *entry,
- gint n_chars)
-{
- GtkEntryPrivate *priv = gtk_entry_get_instance_private (entry);
-
- g_return_if_fail (GTK_IS_ENTRY (entry));
-
- gtk_editable_set_max_width_chars (GTK_EDITABLE (priv->text), n_chars);
-}
-
-/**
- * gtk_entry_get_max_width_chars:
- * @entry: a #GtkEntry
- *
- * Retrieves the desired maximum width of @entry, in characters.
- * See gtk_entry_set_max_width_chars().
- *
- * Returns: the maximum width of the entry, in characters
- */
-gint
-gtk_entry_get_max_width_chars (GtkEntry *entry)
-{
- GtkEntryPrivate *priv = gtk_entry_get_instance_private (entry);
-
- g_return_val_if_fail (GTK_IS_ENTRY (entry), 0);
-
- return gtk_editable_get_max_width_chars (GTK_EDITABLE (priv->text));
-}
-
/**
* gtk_entry_set_has_frame:
* @entry: a #GtkEntry
GDK_AVAILABLE_IN_ALL
gboolean gtk_entry_get_activates_default (GtkEntry *entry);
-GDK_AVAILABLE_IN_ALL
-void gtk_entry_set_width_chars (GtkEntry *entry,
- gint n_chars);
-GDK_AVAILABLE_IN_ALL
-gint gtk_entry_get_width_chars (GtkEntry *entry);
-
-GDK_AVAILABLE_IN_ALL
-void gtk_entry_set_max_width_chars (GtkEntry *entry,
- gint n_chars);
-GDK_AVAILABLE_IN_ALL
-gint gtk_entry_get_max_width_chars (GtkEntry *entry);
-
-/* Somewhat more convenient than the GtkEditable generic functions
- */
-GDK_AVAILABLE_IN_ALL
-void gtk_entry_set_text (GtkEntry *entry,
- const gchar *text);
-/* returns a reference to the text */
-GDK_AVAILABLE_IN_ALL
-const gchar* gtk_entry_get_text (GtkEntry *entry);
-
GDK_AVAILABLE_IN_ALL
void gtk_entry_set_alignment (GtkEntry *entry,
gfloat xalign);
g_free (completion->priv->case_normalized_key);
- tmp = g_utf8_normalize (gtk_entry_get_text (GTK_ENTRY (completion->priv->entry)),
+ tmp = g_utf8_normalize (gtk_editable_get_text (GTK_EDITABLE (completion->priv->entry)),
-1, G_NORMALIZE_ALL);
completion->priv->case_normalized_key = g_utf8_casefold (tmp, -1);
g_free (tmp);
gchar *str = NULL;
gtk_tree_model_get (model, iter, completion->priv->text_column, &str, -1);
- gtk_entry_set_text (GTK_ENTRY (completion->priv->entry), str ? str : "");
+ gtk_editable_set_text (GTK_EDITABLE (completion->priv->entry), str ? str : "");
/* move cursor to the end */
gtk_editable_set_position (GTK_EDITABLE (completion->priv->entry), -1);
prefix_len = g_utf8_strlen (prefix, -1);
- key = gtk_entry_get_text (GTK_ENTRY (completion->priv->entry));
+ key = gtk_editable_get_text (GTK_EDITABLE (completion->priv->entry));
key_len = g_utf8_strlen (key, -1);
if (prefix_len > key_len)
completion->priv->completion_timeout = 0;
if (completion->priv->filter_model &&
- g_utf8_strlen (gtk_entry_get_text (GTK_ENTRY (completion->priv->entry)), -1)
+ g_utf8_strlen (gtk_editable_get_text (GTK_EDITABLE (completion->priv->entry)), -1)
>= completion->priv->minimum_key_length)
{
gint matches;
if (completion->priv->inline_selection &&
completion->priv->completion_prefix)
{
- gtk_entry_set_text (GTK_ENTRY (completion->priv->entry),
- completion->priv->completion_prefix);
+ gtk_editable_set_text (GTK_EDITABLE (completion->priv->entry),
+ completion->priv->completion_prefix);
gtk_editable_set_position (GTK_EDITABLE (widget), -1);
}
}
model = gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER (model));
if (completion->priv->completion_prefix == NULL)
- completion->priv->completion_prefix = g_strdup (gtk_entry_get_text (GTK_ENTRY (completion->priv->entry)));
+ completion->priv->completion_prefix = g_strdup (gtk_editable_get_text (GTK_EDITABLE (completion->priv->entry)));
g_signal_emit_by_name (completion, "cursor-on-match", model,
&child_iter, &entry_set);
if (completion->priv->inline_selection &&
completion->priv->completion_prefix)
{
- gtk_entry_set_text (GTK_ENTRY (completion->priv->entry),
- completion->priv->completion_prefix);
+ gtk_editable_set_text (GTK_EDITABLE (completion->priv->entry),
+ completion->priv->completion_prefix);
gtk_editable_set_position (GTK_EDITABLE (widget), -1);
}
}
if (keyval == GDK_KEY_Escape)
{
if (completion->priv->completion_prefix)
- gtk_entry_set_text (GTK_ENTRY (completion->priv->entry),
- completion->priv->completion_prefix);
+ gtk_editable_set_text (GTK_EDITABLE (completion->priv->entry),
+ completion->priv->completion_prefix);
else
- gtk_entry_set_text (GTK_ENTRY (completion->priv->entry), "");
+ gtk_editable_set_text (GTK_EDITABLE (completion->priv->entry), "");
}
/* Move the cursor to the end for Right/Esc */
completion->priv->text_column, &str,
-1);
- gtk_entry_set_text (GTK_ENTRY (widget), str);
+ gtk_editable_set_text (GTK_EDITABLE (widget), str);
/* move the cursor to the end */
gtk_editable_set_position (GTK_EDITABLE (widget), -1);
* Note that @key is normalized and case-folded (see g_utf8_normalize()
* and g_utf8_casefold()). If this is not appropriate, match functions
* have access to the unmodified key via
- * `gtk_entry_get_text (GTK_ENTRY (gtk_entry_completion_get_entry ()))`.
+ * `gtk_editable_get_text (GTK_EDITABLE (gtk_entry_completion_get_entry ()))`.
*
* Returns: %TRUE if @iter should be displayed as a possible completion
* for @key
(new_text_length > 0 &&
*position <= 1 &&
gtk_entry_get_text_length (GTK_ENTRY (chooser_entry)) >= 2 &&
- gtk_entry_get_text (GTK_ENTRY (chooser_entry))[1] == ':'))
+ gtk_editable_get_text (GTK_EDITABLE (chooser_entry))[1] == ':'))
{
gtk_widget_error_bell (GTK_WIDGET (chooser_entry));
g_signal_stop_emission_by_name (chooser_entry, "insert_text");
/* If deleting a drive letter, delete the colon, too */
if (start_pos == 0 && end_pos == 1 &&
gtk_entry_get_text_length (GTK_ENTRY (chooser_entry)) >= 2 &&
- gtk_entry_get_text (GTK_ENTRY (chooser_entry))[1] == ':')
+ gtk_editable_get_text (GTK_EDITABLE (chooser_entry))[1] == ':')
{
g_signal_handlers_block_by_func (chooser_entry,
G_CALLBACK (delete_text_callback),
g_return_val_if_fail (GTK_IS_FILE_CHOOSER_ENTRY (chooser_entry), NULL);
return gtk_file_chooser_get_directory_for_text (chooser_entry,
- gtk_entry_get_text (GTK_ENTRY (chooser_entry)));
+ gtk_editable_get_text (GTK_EDITABLE (chooser_entry)));
}
/**
g_return_val_if_fail (GTK_IS_FILE_CHOOSER_ENTRY (chooser_entry), NULL);
- text = gtk_entry_get_text (GTK_ENTRY (chooser_entry));
+ text = gtk_editable_get_text (GTK_EDITABLE (chooser_entry));
last_slash = strrchr (text, G_DIR_SEPARATOR);
if (last_slash)
return last_slash + 1;
if (chooser_entry->action == GTK_FILE_CHOOSER_ACTION_SAVE)
{
- str = gtk_entry_get_text (GTK_ENTRY (chooser_entry));
+ str = gtk_editable_get_text (GTK_EDITABLE (chooser_entry));
ext = g_strrstr (str, ".");
if (ext)
{
GtkFileChooserWidgetPrivate *priv = impl->priv;
- gtk_entry_set_text (GTK_ENTRY (priv->new_folder_name_entry), "");
+ gtk_editable_set_text (GTK_EDITABLE (priv->new_folder_name_entry), "");
gtk_widget_set_sensitive (priv->new_folder_create_button, FALSE);
gtk_file_chooser_error_stack_set_error (GTK_FILE_CHOOSER_ERROR_STACK (priv->new_folder_error_stack),
FALSE,
check_valid_child_name (impl,
priv->current_folder,
- gtk_entry_get_text (entry),
+ gtk_editable_get_text (entry),
TRUE,
NULL,
priv->new_folder_error_stack,
GFile *file;
const gchar *name;
- name = gtk_entry_get_text (GTK_ENTRY (priv->new_folder_name_entry));
+ name = gtk_editable_get_text (GTK_EDITABLE (priv->new_folder_name_entry));
file = g_file_get_child_for_display_name (priv->current_folder, name, &error);
gtk_popover_popdown (GTK_POPOVER (priv->new_folder_popover));
check_valid_child_name (impl,
priv->current_folder,
- gtk_entry_get_text (entry),
+ gtk_editable_get_text (GTK_EDITABLE (entry)),
file_type == G_FILE_TYPE_DIRECTORY,
priv->rename_file_source_file,
priv->rename_file_error_stack,
gtk_popover_popdown (GTK_POPOVER (priv->rename_file_popover));
- new_name = gtk_entry_get_text (GTK_ENTRY (priv->rename_file_name_entry));
+ new_name = gtk_editable_get_text (GTK_EDITABLE (priv->rename_file_name_entry));
dest = g_file_get_parent (priv->rename_file_source_file);
if (dest)
rect.x, rect.y, &rect.x, &rect.y);
filename = g_file_get_basename (priv->rename_file_source_file);
- gtk_entry_set_text (GTK_ENTRY(priv->rename_file_name_entry), filename);
+ gtk_editable_set_text (GTK_EDITABLE (priv->rename_file_name_entry), filename);
g_free (filename);
gtk_popover_set_pointing_to (GTK_POPOVER (priv->rename_file_popover), &rect);
_gtk_file_chooser_entry_set_action (GTK_FILE_CHOOSER_ENTRY (priv->location_entry), priv->action);
_gtk_file_chooser_entry_set_file_filter (GTK_FILE_CHOOSER_ENTRY (priv->location_entry),
priv->current_filter);
- gtk_entry_set_width_chars (GTK_ENTRY (priv->location_entry), 45);
+ gtk_editable_set_width_chars (GTK_EDITABLE (priv->location_entry), 45);
gtk_entry_set_activates_default (GTK_ENTRY (priv->location_entry), TRUE);
gtk_widget_set_hexpand (priv->location_entry, TRUE);
}
if (change_entry && !priv->auto_selecting_first_row)
{
g_signal_handlers_block_by_func (priv->location_entry, G_CALLBACK (location_entry_changed_cb), impl);
- gtk_entry_set_text (GTK_ENTRY (priv->location_entry), priv->browse_files_last_selected_name);
+ gtk_editable_set_text (GTK_EDITABLE (priv->location_entry), priv->browse_files_last_selected_name);
g_signal_handlers_unblock_by_func (priv->location_entry, G_CALLBACK (location_entry_changed_cb), impl);
if (priv->action == GTK_FILE_CHOOSER_ACTION_SAVE)
priv->browse_files_last_selected_name = NULL;
g_signal_handlers_block_by_func (priv->location_entry, G_CALLBACK (location_entry_changed_cb), impl);
- gtk_entry_set_text (GTK_ENTRY (priv->location_entry), "");
+ gtk_editable_set_text (GTK_EDITABLE (priv->location_entry), "");
g_signal_handlers_unblock_by_func (priv->location_entry, G_CALLBACK (location_entry_changed_cb), impl);
return;
}
int len;
gboolean clear_entry;
- entry_text = gtk_entry_get_text (GTK_ENTRY (priv->location_entry));
+ entry_text = gtk_editable_get_text (GTK_EDITABLE (priv->location_entry));
len = strlen (entry_text);
if (len != 0)
{
if (clear_entry)
{
g_signal_handlers_block_by_func (priv->location_entry, G_CALLBACK (location_entry_changed_cb), impl);
- gtk_entry_set_text (GTK_ENTRY (priv->location_entry), "");
+ gtk_editable_set_text (GTK_EDITABLE (priv->location_entry), "");
g_signal_handlers_unblock_by_func (priv->location_entry, G_CALLBACK (location_entry_changed_cb), impl);
}
}
priv->current_folder);
if (data->clear_entry)
- gtk_entry_set_text (GTK_ENTRY (priv->location_entry), "");
+ gtk_editable_set_text (GTK_EDITABLE (priv->location_entry), "");
}
/* Create a new list model. This is slightly evil; we store the result value
priv->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER);
pending_select_files_free (impl);
- gtk_entry_set_text (GTK_ENTRY (priv->location_entry), name);
+ gtk_editable_set_text (GTK_EDITABLE (priv->location_entry), name);
}
static gchar *
priv->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER,
NULL);
- return g_strdup (gtk_entry_get_text (GTK_ENTRY (priv->location_entry)));
+ return g_strdup (gtk_editable_get_text (GTK_EDITABLE (priv->location_entry)));
}
static gboolean
chooser_entry = GTK_FILE_CHOOSER_ENTRY (priv->location_entry);
- if (strlen (gtk_entry_get_text (GTK_ENTRY (chooser_entry))) == 0)
+ if (strlen (gtk_editable_get_text (GTK_EDITABLE (chooser_entry))) == 0)
{
*file_ret = NULL;
*is_well_formed_ret = TRUE;
{
GtkFileChooserWidgetPrivate *priv = impl->priv;
- gtk_entry_set_text (GTK_ENTRY (priv->location_entry), path);
+ gtk_editable_set_text (GTK_EDITABLE (priv->location_entry), path);
gtk_editable_set_position (GTK_EDITABLE (priv->location_entry), -1);
}
adjustment = gtk_spin_button_get_adjustment (spin);
value = gtk_adjustment_get_value (adjustment);
text = g_strdup_printf ("%2.4g", value);
- gtk_spin_button_set_text (spin, text);
+ gtk_editable_set_text (GTK_EDITABLE (spin), text);
g_free (text);
return TRUE;
priv->language = pango_language_get_default ();
/* Set default preview text */
- gtk_entry_set_text (GTK_ENTRY (priv->preview), priv->preview_text);
+ gtk_editable_set_text (GTK_EDITABLE (priv->preview), priv->preview_text);
gtk_font_chooser_widget_update_preview_attributes (fontchooser);
g_free (priv->preview_text);
priv->preview_text = g_strdup (text);
- gtk_entry_set_text (GTK_ENTRY (priv->preview), text);
+ gtk_editable_set_text (GTK_EDITABLE (priv->preview), text);
g_object_notify (G_OBJECT (fontchooser), "preview-text");
if (priv->username_entry)
{
- text = gtk_entry_get_text (GTK_ENTRY (priv->username_entry));
+ text = gtk_editable_get_text (GTK_EDITABLE (priv->username_entry));
g_mount_operation_set_username (op, text);
}
if (priv->domain_entry)
{
- text = gtk_entry_get_text (GTK_ENTRY (priv->domain_entry));
+ text = gtk_editable_get_text (GTK_EDITABLE (priv->domain_entry));
g_mount_operation_set_domain (op, text);
}
if (priv->password_entry)
{
- text = gtk_entry_get_text (GTK_ENTRY (priv->password_entry));
+ text = gtk_editable_get_text (GTK_EDITABLE (priv->password_entry));
g_mount_operation_set_password (op, text);
}
if (entry_widget == NULL)
return TRUE;
- text = gtk_entry_get_text (GTK_ENTRY (entry_widget));
+ text = gtk_editable_get_text (GTK_EDITABLE (entry_widget));
return text != NULL && text[0] != '\0';
}
gtk_widget_set_hexpand (entry, TRUE);
if (value)
- gtk_entry_set_text (GTK_ENTRY (entry), value);
+ gtk_editable_set_text (GTK_EDITABLE (entry), value);
gtk_grid_attach (GTK_GRID (operation->priv->grid), label, 0, row, 1, 1);
gtk_grid_attach (GTK_GRID (operation->priv->grid), entry, 1, row, 1, 1);
GList *rows;
GList *l;
- new_name = gtk_entry_get_text (GTK_ENTRY (sidebar->rename_entry));
+ new_name = gtk_editable_get_text (GTK_EDITABLE (sidebar->rename_entry));
if (strcmp (new_name, "") == 0)
{
gchar *new_text;
GFile *file;
- new_text = g_strdup (gtk_entry_get_text (GTK_ENTRY (sidebar->rename_entry)));
+ new_text = g_strdup (gtk_editable_get_text (GTK_EDITABLE (sidebar->rename_entry)));
file = g_file_new_for_uri (sidebar->rename_uri);
if (!_gtk_bookmarks_manager_has_bookmark (sidebar->bookmarks_manager, file))
g_free (sidebar->rename_uri);
sidebar->rename_uri = g_strdup (uri);
- gtk_entry_set_text (GTK_ENTRY (sidebar->rename_entry), name);
+ gtk_editable_set_text (GTK_EDITABLE (sidebar->rename_entry), name);
gtk_popover_set_relative_to (GTK_POPOVER (sidebar->rename_popover), GTK_WIDGET (row));
setup_popover_shadowing (sidebar->rename_popover);
* Otherwise, the user would lost the typed address even if it fails
* to connect.
*/
- gtk_entry_set_text (GTK_ENTRY (priv->address_entry), "");
+ gtk_editable_set_text (GTK_EDITABLE (priv->address_entry), "");
if (priv->should_open_location)
emit_open_location (view, location, priv->open_flags);
if (!gtk_widget_get_sensitive (priv->connect_button))
return;
- uri = gtk_entry_get_text (GTK_ENTRY (priv->address_entry));
+ uri = gtk_editable_get_text (GTK_EDITABLE (priv->address_entry));
if (uri != NULL && uri[0] != '\0')
file = g_file_new_for_commandline_arg (uri);
priv = gtk_places_view_get_instance_private (view);
supported = FALSE;
supported_protocols = g_vfs_get_supported_uri_schemes (g_vfs_get_default ());
- address = g_strdup (gtk_entry_get_text (GTK_ENTRY (priv->address_entry)));
+ address = g_strdup (gtk_editable_get_text (GTK_EDITABLE (priv->address_entry)));
scheme = g_uri_parse_scheme (address);
if (!supported_protocols)
priv = gtk_places_view_get_instance_private (view);
uri = g_object_get_data (G_OBJECT (row), "uri");
- gtk_entry_set_text (GTK_ENTRY (priv->address_entry), uri);
+ gtk_editable_set_text (GTK_EDITABLE (priv->address_entry), uri);
gtk_widget_hide (priv->recent_servers_popover);
}
priv = gtk_places_view_get_instance_private (GTK_PLACES_VIEW (widget));
- gtk_entry_set_text (GTK_ENTRY (priv->address_entry), "");
+ gtk_editable_set_text (GTK_EDITABLE (priv->address_entry), "");
GTK_WIDGET_CLASS (gtk_places_view_parent_class)->map (widget);
}
g_free (*data);
}
- *data = g_strdup (gtk_entry_get_text (entry));
+ *data = g_strdup (gtk_editable_get_text (GTK_EDITABLE (entry)));
}
static void
focus = entry;
if (ai_default[i] != NULL)
- gtk_entry_set_text (GTK_ENTRY (entry), ai_default[i]);
+ gtk_editable_set_text (GTK_EDITABLE (entry), ai_default[i]);
gtk_entry_set_visibility (GTK_ENTRY (entry), ai_visible[i]);
gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE);
{
if (gtk_combo_box_get_has_entry (GTK_COMBO_BOX (combo)))
{
- value = g_strdup (gtk_entry_get_text (GTK_ENTRY (gtk_bin_get_child (GTK_BIN (combo)))));
+ value = g_strdup (gtk_editable_get_text (GTK_EDITABLE (gtk_bin_get_child (GTK_BIN (combo)))));
*custom = TRUE;
}
entry = GTK_ENTRY (gtk_bin_get_child (GTK_BIN (combo)));
- gtk_entry_set_text (entry, filtered_val);
+ gtk_editable_set_text (GTK_EDITABLE (entry), filtered_val);
}
value = filtered_val;
}
const gchar *value;
g_signal_handler_block (priv->source, priv->source_changed_handler);
- value = gtk_entry_get_text (GTK_ENTRY (entry));
+ value = gtk_editable_get_text (GTK_EDITABLE (entry));
if (value)
gtk_printer_option_set (priv->source, value);
g_signal_handler_unblock (priv->source, priv->source_changed_handler);
alternative_set (priv->box, source->value);
break;
case GTK_PRINTER_OPTION_TYPE_STRING:
- gtk_entry_set_text (GTK_ENTRY (priv->entry), source->value);
+ gtk_editable_set_text (GTK_EDITABLE (priv->entry), source->value);
break;
case GTK_PRINTER_OPTION_TYPE_PICKONE_PASSWORD:
case GTK_PRINTER_OPTION_TYPE_PICKONE_PASSCODE:
if (gtk_printer_option_has_choice (source, source->value))
combo_box_set (priv->combo, source->value);
else
- gtk_entry_set_text (entry, source->value);
+ gtk_editable_set_text (GTK_EDITABLE (entry), source->value);
break;
}
{
const gchar *text;
- text = gtk_entry_get_text (GTK_ENTRY (priv->print_at_entry));
+ text = gtk_editable_get_text (GTK_EDITABLE (priv->print_at_entry));
gtk_printer_option_set (option, text);
}
}
gtk_widget_set_sensitive (priv->print_at_radio, FALSE);
gtk_widget_set_sensitive (priv->print_at_entry, FALSE);
gtk_widget_set_sensitive (priv->print_hold_radio, FALSE);
- gtk_entry_set_text (GTK_ENTRY (priv->print_at_entry), "");
+ gtk_editable_set_text (GTK_EDITABLE (priv->print_at_entry), "");
return FALSE;
}
option = gtk_printer_option_set_lookup (priv->options, "gtk-print-time-text");
if (option != NULL)
- gtk_entry_set_text (GTK_ENTRY (priv->print_at_entry), option->value);
+ gtk_editable_set_text (GTK_EDITABLE (priv->print_at_entry), option->value);
priv->updating_print_at = FALSE;
const gchar *copies;
GtkWidget *button;
- copies = gtk_spin_button_get_text (GTK_SPIN_BUTTON (priv->copies_spin));
+ copies = gtk_editable_get_text (GTK_EDITABLE (priv->copies_spin));
can_collate = (*copies != '\0' && atoi (copies) > 1);
caps = priv->manual_capabilities | priv->printer_capabilities;
GtkPageRange *ranges;
gint start, end;
- text = gtk_entry_get_text (GTK_ENTRY (priv->page_range_entry));
+ text = gtk_editable_get_text (GTK_EDITABLE (priv->page_range_entry));
if (*text == 0)
{
g_string_append (s, ",");
}
- gtk_entry_set_text (GTK_ENTRY (priv->page_range_entry), s->str);
+ gtk_editable_set_text (GTK_EDITABLE (priv->page_range_entry), s->str);
g_string_free (s, TRUE);
}
adjustment = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (priv->copies_spin));
- text = gtk_spin_button_get_text (GTK_SPIN_BUTTON (priv->copies_spin));
+ text = gtk_editable_get_text (GTK_EDITABLE (priv->copies_spin));
n_copies = g_ascii_strtoull (text, &endptr, 0);
if (gtk_widget_is_sensitive (dialog->priv->copies_spin))
gpointer value;
gboolean has_result;
- text = gtk_entry_get_text (GTK_ENTRY (search_entry));
+ text = gtk_editable_get_text (GTK_EDITABLE (search_entry));
if (!text || !*text)
{
*
* The ::input signal can be used to influence the conversion of
* the users input into a double value. The signal handler is
- * expected to use gtk_spin_button_get_text() to retrieve the text of
+ * expected to use gtk_editable_get_text() to retrieve the text of
* the spinbutton and set @new_value to the new value.
*
* The default conversion uses g_strtod().
else
gtk_spin_button_set_value (spin_button, val);
}
-
-/**
- * gtk_spin_button_get_text:
- * @spin_button: a #GtkSpinButton
- *
- * Returns the text shown in the entry.
- *
- * Returns: (transfer none): The current text shown in the entry area of @spin_button.
- */
-const char *
-gtk_spin_button_get_text (GtkSpinButton *spin_button)
-{
- GtkSpinButtonPrivate *priv = gtk_spin_button_get_instance_private (spin_button);
-
- g_return_val_if_fail (GTK_IS_SPIN_BUTTON (spin_button), NULL);
-
- return gtk_editable_get_text (GTK_EDITABLE (priv->entry));
-}
-
-/**
- * gtk_spin_button_set_text:
- * @spin_button: a #GtkSpinButton
- * @text: The text to set
- *
- * Sets the current text of the spinbutton. Note that setting this will not change
- * the value of the adjustment @spin_button.
- */
-void
-gtk_spin_button_set_text (GtkSpinButton *spin_button,
- const char *text)
-{
- GtkSpinButtonPrivate *priv = gtk_spin_button_get_instance_private (spin_button);
-
- g_return_if_fail (GTK_IS_SPIN_BUTTON (spin_button));
-
- gtk_editable_set_text (GTK_EDITABLE (priv->entry), text);
-}
-
-/**
- * gtk_spin_button_get_max_width_chars:
- * @spin_button: a #GtkSpinButton
- *
- * Retrieves the desired maximum width of @spin_button, in characters.
- * Note that this only applies to the entry area of @spin_button, not the
- * spin button. This is especially important for horizontal spinbuttons.
- *
- * See also #GtkEntry:max-width-chars
- *
- * Returns: the maximum width of the spin button, in characters
- */
-int
-gtk_spin_button_get_max_width_chars (GtkSpinButton *spin_button)
-{
- GtkSpinButtonPrivate *priv = gtk_spin_button_get_instance_private (spin_button);
-
- g_return_val_if_fail (GTK_IS_SPIN_BUTTON (spin_button), -1);
-
- return gtk_editable_get_max_width_chars (GTK_EDITABLE (priv->entry));
-}
-
-/**
- * gtk_spin_button_set_max_width_chars:
- * @spin_button: a #GtkSpinButton
- * @max_width_chars: new desired maximum width in chars
- *
- * Sets the desired maximum width of @spin_button, in characters.
- * Note that this only applies to the entry area of @spin_button, not the
- * spin button. This is especially important for horizontal spinbuttons.
- */
-void
-gtk_spin_button_set_max_width_chars (GtkSpinButton *spin_button,
- int max_width_chars)
-{
- GtkSpinButtonPrivate *priv = gtk_spin_button_get_instance_private (spin_button);
-
- g_return_if_fail (GTK_IS_SPIN_BUTTON (spin_button));
-
- gtk_editable_set_max_width_chars (GTK_EDITABLE (priv->entry), max_width_chars);
-}
-
-/**
- * gtk_spin_button_get_width_chars:
- * @spin_button: a #GtkSpinButton
- *
- * Get the value set by gtk_spin_button_set_width_chars(). Note that this
- * value only applies to the entry area of @spin_button.
- *
- * Returns: The number of characters to request space for in the entry
- * area of @spin_button
- */
-int
-gtk_spin_button_get_width_chars (GtkSpinButton *spin_button)
-{
- GtkSpinButtonPrivate *priv = gtk_spin_button_get_instance_private (spin_button);
-
- g_return_val_if_fail (GTK_IS_SPIN_BUTTON (spin_button), -1);
-
- return gtk_editable_get_width_chars (GTK_EDITABLE (priv->entry));
-}
-
-/**
- * gtk_spin_button_set_width_chars:
- * @spin_button: a #GtkSpinButton
- * @width_chars: desired width in characters
- *
- * Changes the size request of the entry area of @spin_button
- * to be about the right size for @width_chars characters.
- */
-void
-gtk_spin_button_set_width_chars (GtkSpinButton *spin_button,
- int width_chars)
-{
- GtkSpinButtonPrivate *priv = gtk_spin_button_get_instance_private (spin_button);
-
- g_return_if_fail (GTK_IS_SPIN_BUTTON (spin_button));
-
- gtk_editable_set_width_chars (GTK_EDITABLE (priv->entry), width_chars);
-}
gboolean gtk_spin_button_get_snap_to_ticks (GtkSpinButton *spin_button);
GDK_AVAILABLE_IN_ALL
void gtk_spin_button_update (GtkSpinButton *spin_button);
-GDK_AVAILABLE_IN_ALL
-const char * gtk_spin_button_get_text (GtkSpinButton *spin_button);
-GDK_AVAILABLE_IN_ALL
-void gtk_spin_button_set_text (GtkSpinButton *spin_button,
- const char *text);
-GDK_AVAILABLE_IN_ALL
-int gtk_spin_button_get_max_width_chars (GtkSpinButton *spin_button);
-GDK_AVAILABLE_IN_ALL
-void gtk_spin_button_set_max_width_chars (GtkSpinButton *spin_button,
- int max_width_chars);
-GDK_AVAILABLE_IN_ALL
-int gtk_spin_button_get_width_chars (GtkSpinButton *spin_button);
-GDK_AVAILABLE_IN_ALL
-void gtk_spin_button_set_width_chars (GtkSpinButton *spin_button,
- int width_chars);
GtkTreeModel *model;
GtkTreeSelection *selection;
- text = gtk_entry_get_text (GTK_ENTRY (tree_view->priv->search_entry));
+ text = gtk_editable_get_text (GTK_EDITABLE (tree_view->priv->search_entry));
g_return_val_if_fail (text != NULL, FALSE);
else if (g_variant_type_equal (type, G_VARIANT_TYPE_STRING))
{
GtkEntry *entry = GTK_ENTRY (editor);
- gtk_entry_set_text (entry, g_variant_get_string (value, NULL));
+ gtk_editable_set_text (GTK_EDITABLE (entry), g_variant_get_string (value, NULL));
}
else
{
g_list_free (children);
text = g_variant_print (value, FALSE);
- gtk_entry_set_text (entry, text);
+ gtk_editable_set_text (GTK_EDITABLE (entry), text);
g_free (text);
}
else if (g_variant_type_equal (type, G_VARIANT_TYPE_STRING))
{
GtkEntry *entry = GTK_ENTRY (editor);
- value = g_variant_new_string (gtk_entry_get_text (entry));
+ value = g_variant_new_string (gtk_editable_get_text (GTK_EDITABLE (entry)));
}
else
{
children = gtk_container_get_children (GTK_CONTAINER (editor));
entry = children->data;
- text = gtk_entry_get_text (entry);
+ text = gtk_editable_get_text (GTK_EDITABLE (entry));
g_list_free (children);
value = g_variant_parse (type, text, NULL, NULL, NULL);
GValue val = G_VALUE_INIT;
g_value_init (&val, G_TYPE_STRING);
- g_value_set_static_string (&val, gtk_entry_get_text (entry));
+ g_value_set_static_string (&val, gtk_editable_get_text (GTK_EDITABLE (entry)));
set_property_value (p->obj, p->spec, &val);
g_value_unset (&val);
}
{
const gchar *s;
- s = g_intern_string (gtk_entry_get_text (entry));
+ s = g_intern_string (gtk_editable_get_text (GTK_EDITABLE (entry)));
if (g_str_equal (p->spec->name, "id"))
gtk_css_node_set_id (GTK_CSS_NODE (p->obj), s);
else if (g_str_equal (p->spec->name, "name"))
str = g_value_get_string (&val);
if (str == NULL)
str = "";
- text = gtk_entry_get_text (entry);
+ text = gtk_editable_get_text (GTK_EDITABLE (entry));
if (g_strcmp0 (str, text) != 0)
{
block_controller (G_OBJECT (entry));
- gtk_entry_set_text (entry, str);
+ gtk_editable_set_text (GTK_EDITABLE (entry), str);
unblock_controller (G_OBJECT (entry));
}
static gunichar
unichar_get_value (GtkEntry *entry)
{
- const gchar *text = gtk_entry_get_text (entry);
+ const gchar *text = gtk_editable_get_text (GTK_EDITABLE (entry));
if (text[0])
return g_utf8_get_char (text);
buf[len] = '\0';
block_controller (G_OBJECT (entry));
- gtk_entry_set_text (entry, buf);
+ gtk_editable_set_text (GTK_EDITABLE (entry), buf);
unblock_controller (G_OBJECT (entry));
}
}
gtk_widget_show (box);
entry = gtk_entry_new ();
- gtk_entry_set_text (GTK_ENTRY (entry), str);
+ gtk_editable_set_text (GTK_EDITABLE (entry), str);
gtk_widget_show (entry);
gtk_container_add (GTK_CONTAINER (box), entry);
g_object_set_data (G_OBJECT (box), "entry", entry);
GtkEntry *entry;
entry = GTK_ENTRY (g_object_get_data (G_OBJECT (l->data), "entry"));
- g_ptr_array_add (p, g_strdup (gtk_entry_get_text (entry)));
+ g_ptr_array_add (p, g_strdup (gtk_editable_get_text (GTK_EDITABLE (entry))));
}
g_list_free (children);
{
gchar *str = g_strdup_printf ("%0.2f", factor);
- gtk_entry_set_text (GTK_ENTRY (vis->priv->font_scale_entry), str);
+ gtk_editable_set_text (GTK_EDITABLE (vis->priv->font_scale_entry), str);
g_free (str);
}
}
gdouble factor;
gchar *err = NULL;
- factor = g_strtod (gtk_entry_get_text (entry), &err);
+ factor = g_strtod (gtk_editable_get_text (GTK_EDITABLE (entry)), &err);
if (err != NULL)
update_font_scale (vis, factor, TRUE, FALSE);
}
{
gchar *str = g_strdup_printf ("%0.*f", 2, slowdown);
- gtk_entry_set_text (GTK_ENTRY (vis->priv->slowdown_entry), str);
+ gtk_editable_set_text (GTK_EDITABLE (vis->priv->slowdown_entry), str);
g_free (str);
}
}
gdouble slowdown;
gchar *err = NULL;
- slowdown = g_strtod (gtk_entry_get_text (entry), &err);
+ slowdown = g_strtod (gtk_editable_get_text (GTK_EDITABLE (entry)), &err);
if (err != NULL)
update_slowdown (vis, slowdown, TRUE, FALSE);
}
for (i = 0; i < 3; i++) {
entry = gtk_entry_new ();
- gtk_entry_set_text (GTK_ENTRY (entry), "│XYyj,Ö...");
+ gtk_editable_set_text (GTK_EDITABLE (entry), "│XYyj,Ö...");
set_font_size (entry, i);
GdkRGBA rgba;
const char *text;
- text = gtk_entry_get_text (entry);
+ text = gtk_editable_get_text (GTK_EDITABLE (entry));
g_signal_handlers_block_by_func (entry, rgba_changed, entry);
if (gdk_rgba_parse (&rgba, text))
s = gdk_rgba_to_string (&color);
g_signal_handlers_block_by_func (entry, text_activated, chooser);
- gtk_entry_set_text (GTK_ENTRY (entry), s);
+ gtk_editable_set_text (GTK_EDITABLE (entry), s);
g_signal_handlers_unblock_by_func (entry, text_activated, chooser);
g_free (s);
entry = gtk_entry_completion_get_entry (completion);
gtk_tree_model_get (GTK_TREE_MODEL (model), iter, 1, &str, -1);
- gtk_entry_set_text (GTK_ENTRY (entry), str);
+ gtk_editable_set_text (GTK_EDITABLE (entry), str);
gtk_editable_set_position (GTK_EDITABLE (entry), -1);
g_free (str);
clear_pressed (GtkEntry *entry, gint icon, gpointer data)
{
if (icon == GTK_ENTRY_ICON_SECONDARY)
- gtk_entry_set_text (entry, "");
+ gtk_editable_set_text (GTK_EDITABLE (entry), "");
}
static void
entry = gtk_entry_new ();
gtk_widget_set_hexpand (entry, TRUE);
gtk_grid_attach (GTK_GRID (grid), entry, 1, 1, 1, 1);
- gtk_entry_set_text (GTK_ENTRY (entry), "Right-to-left");
+ gtk_editable_set_text (GTK_EDITABLE (entry), "Right-to-left");
gtk_widget_set_direction (entry, GTK_TEXT_DIR_RTL);
gtk_entry_set_icon_from_icon_name (GTK_ENTRY (entry),
gtk_container_add (GTK_CONTAINER (box2), hbox);
entry = gtk_entry_new ();
- gtk_entry_set_text (GTK_ENTRY (entry), "hello world \330\247\331\204\330\263\331\204\330\247\331\205 \330\271\331\204\331\212\331\203\331\205");
+ gtk_editable_set_text (GTK_EDITABLE (entry), "hello world \330\247\331\204\330\263\331\204\330\247\331\205 \330\271\331\204\331\212\331\203\331\205");
gtk_editable_select_region (GTK_EDITABLE (entry), 0, 5);
gtk_container_add (GTK_CONTAINER (hbox), entry);
gtk_combo_box_text_append_text (cb, "item9 item9");
cb_entry = gtk_bin_get_child (GTK_BIN (cb));
- gtk_entry_set_text (GTK_ENTRY (cb_entry), "hello world \n\n\n foo");
+ gtk_editable_set_text (GTK_EDITABLE (cb_entry), "hello world \n\n\n foo");
gtk_editable_select_region (GTK_EDITABLE (cb_entry), 0, -1);
gtk_container_add (GTK_CONTAINER (box2), GTK_WIDGET (cb));
hours = gtk_adjustment_get_value (adjustment) / 60.0;
minutes = (fabs(floor (hours) - hours) < 1e-5) ? 0.0 : 30;
sprintf (buf, "%02.0f:%02.0f", floor (hours), minutes);
- if (strcmp (buf, gtk_spin_button_get_text (spin_button)))
- gtk_spin_button_set_text (spin_button, buf);
+ if (strcmp (buf, gtk_editable_get_text (GTK_EDITABLE (spin_button))))
+ gtk_editable_set_text (GTK_EDITABLE (spin_button), buf);
return TRUE;
}
for (i = 1; i <= 12; i++)
{
tmp1 = g_ascii_strup (month[i - 1], -1);
- tmp2 = g_ascii_strup (gtk_spin_button_get_text (spin_button), -1);
+ tmp2 = g_ascii_strup (gtk_editable_get_text (GTK_EDITABLE (spin_button)), -1);
if (strstr (tmp1, tmp2) == tmp1)
found = TRUE;
g_free (tmp1);
for (i = 1; i <= 12; i++)
if (fabs (value - (double)i) < 1e-5)
{
- if (strcmp (month[i-1], gtk_spin_button_get_text (spin_button)))
- gtk_spin_button_set_text (spin_button, month[i-1]);
+ if (strcmp (month[i-1], gtk_editable_get_text (GTK_EDITABLE (spin_button))))
+ gtk_editable_set_text (GTK_EDITABLE (spin_button), month[i-1]);
}
return TRUE;
}
gchar *err;
gdouble res;
- buf = gtk_spin_button_get_text (GTK_SPIN_BUTTON (spin_button));
+ buf = gtk_editable_get_text (GTK_EDITABLE (spin_button));
res = strtol(buf, &err, 16);
*new_val = res;
if (*err)
sprintf (buf, "0x00");
else
sprintf (buf, "0x%.2X", (gint) val);
- if (strcmp (buf, gtk_spin_button_get_text (spin_button)))
- gtk_spin_button_set_text (spin_button, buf);
+ if (strcmp (buf, gtk_editable_get_text (GTK_EDITABLE (spin_button))))
+ gtk_editable_set_text (GTK_EDITABLE (spin_button), buf);
return TRUE;
}
G_CALLBACK (spin_button_time_output_func),
NULL);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
- gtk_spin_button_set_width_chars (GTK_SPIN_BUTTON (spinner), 5);
+ gtk_editable_set_width_chars (GTK_EDITABLE (spinner), 5);
gtk_container_add (GTK_CONTAINER (vbox2), spinner);
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
G_CALLBACK (spin_button_month_output_func),
NULL);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
- gtk_spin_button_set_width_chars (GTK_SPIN_BUTTON (spinner), 9);
+ gtk_editable_set_width_chars (GTK_EDITABLE (spinner), 9);
gtk_container_add (GTK_CONTAINER (vbox2), spinner);
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
G_CALLBACK (spin_button_hex_output_func),
NULL);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
- gtk_spin_button_set_width_chars (GTK_SPIN_BUTTON (spinner), 4);
+ gtk_editable_set_width_chars (GTK_EDITABLE (spinner), 4);
gtk_container_add (GTK_CONTAINER (vbox2), spinner);
frame = gtk_frame_new ("Accelerated");
else
i = (i + n - 1) % n;
- gtk_entry_set_text (GTK_ENTRY (entry), cursor_names[i]);
+ gtk_editable_set_text (GTK_EDITABLE (entry), cursor_names[i]);
}
static void
{
const gchar *name;
- name = gtk_entry_get_text (GTK_ENTRY (entry));
+ name = gtk_editable_get_text (GTK_EDITABLE (entry));
gtk_widget_set_cursor_from_name (widget, name);
g_object_set_data_full (G_OBJECT (widget), "name", g_strdup (name), g_free);
children = gtk_container_get_children (GTK_CONTAINER (data));
- theme = gtk_entry_get_text (GTK_ENTRY (children->next->data));
+ theme = gtk_editable_get_text (GTK_EDITABLE (children->next->data));
size = (gint) gtk_spin_button_get_value (GTK_SPIN_BUTTON (children->next->next->data));
g_list_free (children);
gtk_container_add (GTK_CONTAINER (hbox), label);
entry = gtk_entry_new ();
- gtk_entry_set_text (GTK_ENTRY (entry), "default");
+ gtk_editable_set_text (GTK_EDITABLE (entry), "default");
gtk_container_add (GTK_CONTAINER (hbox), entry);
size = gtk_spin_button_new_with_range (1.0, 128.0, 1.0);
gtk_widget_show (window);
- gtk_entry_set_text (GTK_ENTRY (entry), "arrow");
+ gtk_editable_set_text (GTK_EDITABLE (entry), "arrow");
}
else
gtk_widget_destroy (window);
GdkDisplay *new_display = NULL;
GdkDisplay *current_display = gtk_widget_get_display (widget);
- display_name = gtk_entry_get_text (GTK_ENTRY (data->entry));
+ display_name = gtk_editable_get_text (GTK_EDITABLE (data->entry));
display = gdk_display_open (display_name);
if (!display)
combo_dpy = gtk_combo_box_text_new_with_entry ();
gtk_widget_set_hexpand (combo_dpy, TRUE);
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_dpy), "diabolo:0.0");
- gtk_entry_set_text (GTK_ENTRY (gtk_bin_get_child (GTK_BIN (combo_dpy))),
- "<hostname>:<X Server Num>.<Screen Num>");
+ gtk_editable_set_text (GTK_EDITABLE (gtk_bin_get_child (GTK_BIN (combo_dpy))),
+ "<hostname>:<X Server Num>.<Screen Num>");
gtk_grid_attach (GTK_GRID (grid), label_dpy, 0, 0, 1, 1);
gtk_grid_attach (GTK_GRID (grid), combo_dpy, 0, 1, 1, 1);
entry_changed (GtkWidget *widget, ProgressData *pdata)
{
gtk_progress_bar_set_text (GTK_PROGRESS_BAR (pdata->pbar),
- gtk_entry_get_text (GTK_ENTRY (pdata->entry)));
+ gtk_editable_get_text (GTK_EDITABLE (pdata->entry)));
}
void
guint cookie;
active = gtk_toggle_button_get_active (button);
- reason = gtk_entry_get_text (GTK_ENTRY (inhibit_entry));
+ reason = gtk_editable_get_text (GTK_EDITABLE (inhibit_entry));
flags = 0;
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (inhibit_logout)))
GtkWidget *page, *title;
page = gtk_entry_new ();
- gtk_entry_set_text (GTK_ENTRY (page), "Addition");
+ gtk_editable_set_text (GTK_EDITABLE (page), "Addition");
title = gtk_label_new ("Addition");
while (*labels)
{
page = gtk_entry_new ();
- gtk_entry_set_text (GTK_ENTRY (page), *labels);
+ gtk_editable_set_text (GTK_EDITABLE (page), *labels);
title = gtk_label_new (*labels);
gtk_widget_set_halign (revealer, GTK_ALIGN_START);
gtk_widget_set_valign (revealer, GTK_ALIGN_START);
entry = gtk_entry_new ();
- gtk_entry_set_text (GTK_ENTRY (entry), "00000");
+ gtk_editable_set_text (GTK_EDITABLE (entry), "00000");
gtk_container_add (GTK_CONTAINER (revealer), entry);
g_object_bind_property (widget, "active", revealer, "reveal-child", 0);
gtk_revealer_set_transition_type (GTK_REVEALER (revealer), GTK_REVEALER_TRANSITION_TYPE_NONE);
gtk_widget_set_halign (revealer, GTK_ALIGN_END);
gtk_widget_set_valign (revealer, GTK_ALIGN_END);
entry = gtk_entry_new ();
- gtk_entry_set_text (GTK_ENTRY (entry), "00000");
+ gtk_editable_set_text (GTK_EDITABLE (entry), "00000");
gtk_container_add (GTK_CONTAINER (revealer), entry);
g_object_bind_property (widget, "active", revealer, "reveal-child", 0);
gtk_revealer_set_transition_type (GTK_REVEALER (revealer), GTK_REVEALER_TRANSITION_TYPE_CROSSFADE);
gtk_widget_set_hexpand (revealer, TRUE);
gtk_widget_set_halign (revealer, GTK_ALIGN_START);
entry = gtk_entry_new ();
- gtk_entry_set_text (GTK_ENTRY (entry), "12345");
+ gtk_editable_set_text (GTK_EDITABLE (entry), "12345");
gtk_container_add (GTK_CONTAINER (revealer), entry);
g_object_bind_property (widget, "active", revealer, "reveal-child", 0);
gtk_revealer_set_transition_type (GTK_REVEALER (revealer), GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT);
gtk_widget_set_vexpand (revealer, TRUE);
gtk_widget_set_valign (revealer, GTK_ALIGN_START);
entry = gtk_entry_new ();
- gtk_entry_set_text (GTK_ENTRY (entry), "23456");
+ gtk_editable_set_text (GTK_ENTRY (entry), "23456");
gtk_container_add (GTK_CONTAINER (revealer), entry);
g_object_bind_property (widget, "active", revealer, "reveal-child", 0);
gtk_revealer_set_transition_type (GTK_REVEALER (revealer), GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN);
gtk_widget_set_hexpand (revealer, TRUE);
gtk_widget_set_halign (revealer, GTK_ALIGN_END);
entry = gtk_entry_new ();
- gtk_entry_set_text (GTK_ENTRY (entry), "34567");
+ gtk_editable_set_text (GTK_EDITABLE (entry), "34567");
gtk_container_add (GTK_CONTAINER (revealer), entry);
g_object_bind_property (widget, "active", revealer, "reveal-child", 0);
gtk_revealer_set_transition_type (GTK_REVEALER (revealer), GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT);
gtk_widget_set_vexpand (revealer, TRUE);
gtk_widget_set_valign (revealer, GTK_ALIGN_END);
entry = gtk_entry_new ();
- gtk_entry_set_text (GTK_ENTRY (entry), "45678");
+ gtk_editable_set_text (GTK_EDITABLE (entry), "45678");
gtk_container_add (GTK_CONTAINER (revealer), entry);
g_object_bind_property (widget, "active", revealer, "reveal-child", 0);
gtk_revealer_set_transition_type (GTK_REVEALER (revealer), GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP);
{
const gchar *layout;
- layout = gtk_entry_get_text (entry);
+ layout = gtk_editable_get_text (GTK_EDITABLE (entry));
gtk_header_bar_set_decoration_layout (bar, layout);
}
entry = gtk_entry_new ();
g_object_get (gtk_widget_get_settings (window), "gtk-decoration-layout", &layout, NULL);
- gtk_entry_set_text (GTK_ENTRY (entry), layout);
+ gtk_editable_set_text (GTK_EDITABLE (entry), layout);
g_free (layout);
g_signal_connect (entry, "notify::text",
path = g_file_get_path (file);
- result = strstr (path, gtk_entry_get_text (GTK_ENTRY (search_entry))) != NULL;
+ result = strstr (path, gtk_editable_get_text (GTK_EDITABLE (search_entry))) != NULL;
g_object_unref (info);
g_free (path);
gtk_tree_store_insert (GTK_TREE_STORE (model),
&iter,
&selected,
- atoi (gtk_entry_get_text (GTK_ENTRY (entry))));
+ atoi (gtk_editable_get_text (GTK_EDITABLE (entry))));
}
else
{
gtk_tree_store_insert (GTK_TREE_STORE (model),
&iter,
NULL,
- atoi (gtk_entry_get_text (GTK_ENTRY (entry))));
+ atoi (gtk_editable_get_text (GTK_EDITABLE (entry))));
}
node_set (&iter);
gtk_tree_store_set (GTK_TREE_STORE (model),
&selected,
1,
- gtk_entry_get_text (GTK_ENTRY (entry)),
+ gtk_editable_get_text (GTK_EDITABLE (entry)),
-1);
}
}
entry = g_object_get_data (G_OBJECT (button), "user_data");
str1 = g_strdup_printf ("Row (<span color=\"red\">%d</span>)", node_count++);
- str2 = g_strdup_printf ("%d", atoi (gtk_entry_get_text (GTK_ENTRY (entry))));
+ str2 = g_strdup_printf ("%d", atoi (gtk_editable_get_text (GTK_EDITABLE (entry))));
if (gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)),
NULL,
entry = gtk_entry_new ();
g_object_ref_sink (entry);
- gtk_entry_set_text (GTK_ENTRY (entry), "bar");
+ gtk_editable_set_text (GTK_EDITABLE (entry), "bar");
gtk_editable_set_position (GTK_EDITABLE (entry), -1);
pos = gtk_editable_get_position (GTK_EDITABLE (entry));
g_assert_cmpint (pos, ==, 3);
entry = gtk_entry_new ();
g_object_ref_sink (entry);
- gtk_entry_set_text (GTK_ENTRY (entry), "foobar");
+ gtk_editable_set_text (GTK_EDITABLE (entry), "foobar");
gtk_editable_set_position (GTK_EDITABLE (entry), -1);
pos = gtk_editable_get_position (GTK_EDITABLE (entry));
g_assert_cmpint (pos, ==, 6);
projects / gtk4.git / commitdiff